// Generated from MessagingGrammar.g4 by ANTLR 4.2

  package gatperdut.chato.core.messaging.grammar.generated;
  import gatperdut.chato.core.messaging.grammar.messinfo.MessageInfo;
  import gatperdut.chato.core.messaging.grammar.messinfo.ListRoomsInfo;
  import gatperdut.chato.core.messaging.grammar.messinfo.ListPlayersInfo;
  import gatperdut.chato.core.messaging.grammar.messinfo.ListItemTemplatesInfo;
  import gatperdut.chato.core.messaging.grammar.messinfo.ListItemsInRoomInfo;
  import gatperdut.chato.core.messaging.grammar.messinfo.CreateRoomInfo;
  import gatperdut.chato.core.messaging.grammar.messinfo.CreatePlayerInfo;
  import gatperdut.chato.core.messaging.grammar.messinfo.CreateItemTemplateInfo;
  import gatperdut.chato.core.messaging.grammar.messinfo.UpdateRoomsInfo;
  import gatperdut.chato.core.messaging.grammar.messinfo.UpdateItemsInfo;

import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class MessagingGrammarParser extends Parser {
	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		T__8=1, T__7=2, T__6=3, T__5=4, T__4=5, T__3=6, T__2=7, T__1=8, T__0=9, 
		STRING=10, NUMBER=11, LIST=12, CREATE=13, UPDATE=14, ROOMS=15, PLAYERS=16, 
		ITEM_TEMPLATES=17, ITEMS=18, ITEMS_IN_ROOM=19, WS=20;
	public static final String[] tokenNames = {
		"<INVALID>", "']'", "'{'", "'null'", "','", "'['", "':'", "'false'", "'}'", 
		"'true'", "STRING", "NUMBER", "'list'", "'create'", "'update'", "'rooms'", 
		"'players'", "'item_templates'", "'items'", "'items_in_room'", "WS"
	};
	public static final int
		RULE_command = 0, RULE_list = 1, RULE_create = 2, RULE_update = 3, RULE_json = 4, 
		RULE_object = 5, RULE_pair = 6, RULE_array = 7, RULE_value = 8;
	public static final String[] ruleNames = {
		"command", "list", "create", "update", "json", "object", "pair", "array", 
		"value"
	};

	@Override
	public String getGrammarFileName() { return "MessagingGrammar.g4"; }

	@Override
	public String[] getTokenNames() { return tokenNames; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public String getSerializedATN() { return _serializedATN; }

	@Override
	public ATN getATN() { return _ATN; }


	  	
	  private MessageInfo mi;
	  

	public MessagingGrammarParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}
	public static class CommandContext extends ParserRuleContext {
		public MessageInfo messageInfo;
		public ListContext list() {
			return getRuleContext(ListContext.class,0);
		}
		public UpdateContext update() {
			return getRuleContext(UpdateContext.class,0);
		}
		public CreateContext create() {
			return getRuleContext(CreateContext.class,0);
		}
		public CommandContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_command; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof MessagingGrammarListener ) ((MessagingGrammarListener)listener).enterCommand(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof MessagingGrammarListener ) ((MessagingGrammarListener)listener).exitCommand(this);
		}
	}

	public final CommandContext command() throws RecognitionException {
		CommandContext _localctx = new CommandContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_command);
		try {
			setState(22);
			switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(19); list();
				}
				break;

			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(20); create();
				}
				break;

			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(21); update();
				}
				break;
			}

				 ((CommandContext)_localctx).messageInfo =  mi;

		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ListContext extends ParserRuleContext {
		public Token roomID;
		public List<TerminalNode> WS() { return getTokens(MessagingGrammarParser.WS); }
		public TerminalNode PLAYERS() { return getToken(MessagingGrammarParser.PLAYERS, 0); }
		public TerminalNode ITEMS_IN_ROOM() { return getToken(MessagingGrammarParser.ITEMS_IN_ROOM, 0); }
		public TerminalNode NUMBER() { return getToken(MessagingGrammarParser.NUMBER, 0); }
		public TerminalNode ROOMS() { return getToken(MessagingGrammarParser.ROOMS, 0); }
		public TerminalNode WS(int i) {
			return getToken(MessagingGrammarParser.WS, i);
		}
		public TerminalNode ITEM_TEMPLATES() { return getToken(MessagingGrammarParser.ITEM_TEMPLATES, 0); }
		public TerminalNode LIST() { return getToken(MessagingGrammarParser.LIST, 0); }
		public ListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_list; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof MessagingGrammarListener ) ((MessagingGrammarListener)listener).enterList(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof MessagingGrammarListener ) ((MessagingGrammarListener)listener).exitList(this);
		}
	}

	public final ListContext list() throws RecognitionException {
		ListContext _localctx = new ListContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_list);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(25);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(24); match(WS);
				}
			}

			setState(27); match(LIST);
			setState(28); match(WS);
			setState(39);
			switch (_input.LA(1)) {
			case ROOMS:
				{
				setState(29); match(ROOMS);

						mi = new ListRoomsInfo();	
					
				}
				break;
			case PLAYERS:
				{
				setState(31); match(PLAYERS);

						mi = new ListPlayersInfo();
					
				}
				break;
			case ITEM_TEMPLATES:
				{
				setState(33); match(ITEM_TEMPLATES);

						mi = new ListItemTemplatesInfo();
					
				}
				break;
			case ITEMS_IN_ROOM:
				{
				setState(35); match(ITEMS_IN_ROOM);
				setState(36); match(WS);
				setState(37); ((ListContext)_localctx).roomID = match(NUMBER);

						mi = new ListItemsInRoomInfo( (((ListContext)_localctx).roomID!=null?((ListContext)_localctx).roomID.getText():null) );
					
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(42);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(41); match(WS);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CreateContext extends ParserRuleContext {
		public JsonContext pd;
		public TerminalNode CREATE() { return getToken(MessagingGrammarParser.CREATE, 0); }
		public List<TerminalNode> WS() { return getTokens(MessagingGrammarParser.WS); }
		public TerminalNode PLAYERS() { return getToken(MessagingGrammarParser.PLAYERS, 0); }
		public JsonContext json() {
			return getRuleContext(JsonContext.class,0);
		}
		public TerminalNode ROOMS() { return getToken(MessagingGrammarParser.ROOMS, 0); }
		public TerminalNode WS(int i) {
			return getToken(MessagingGrammarParser.WS, i);
		}
		public TerminalNode ITEM_TEMPLATES() { return getToken(MessagingGrammarParser.ITEM_TEMPLATES, 0); }
		public CreateContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_create; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof MessagingGrammarListener ) ((MessagingGrammarListener)listener).enterCreate(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof MessagingGrammarListener ) ((MessagingGrammarListener)listener).exitCreate(this);
		}
	}

	public final CreateContext create() throws RecognitionException {
		CreateContext _localctx = new CreateContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_create);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(45);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(44); match(WS);
				}
			}

			setState(47); match(CREATE);
			setState(48); match(WS);
			setState(65);
			switch (_input.LA(1)) {
			case ROOMS:
				{
				setState(49); match(ROOMS);

						mi = new CreateRoomInfo();	
					
				}
				break;
			case PLAYERS:
				{
				setState(51); match(PLAYERS);
				setState(53);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(52); match(WS);
					}
				}

				setState(55); ((CreateContext)_localctx).pd = json();

						mi = new CreatePlayerInfo( (((CreateContext)_localctx).pd!=null?_input.getText(((CreateContext)_localctx).pd.start,((CreateContext)_localctx).pd.stop):null) );
					
				}
				break;
			case ITEM_TEMPLATES:
				{
				setState(58); match(ITEM_TEMPLATES);
				setState(60);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(59); match(WS);
					}
				}

				setState(62); ((CreateContext)_localctx).pd = json();

						mi = new CreateItemTemplateInfo( (((CreateContext)_localctx).pd!=null?_input.getText(((CreateContext)_localctx).pd.start,((CreateContext)_localctx).pd.stop):null) );
					
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(68);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(67); match(WS);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UpdateContext extends ParserRuleContext {
		public JsonContext rd;
		public JsonContext id;
		public List<TerminalNode> WS() { return getTokens(MessagingGrammarParser.WS); }
		public TerminalNode ITEMS() { return getToken(MessagingGrammarParser.ITEMS, 0); }
		public JsonContext json() {
			return getRuleContext(JsonContext.class,0);
		}
		public TerminalNode ROOMS() { return getToken(MessagingGrammarParser.ROOMS, 0); }
		public TerminalNode WS(int i) {
			return getToken(MessagingGrammarParser.WS, i);
		}
		public TerminalNode UPDATE() { return getToken(MessagingGrammarParser.UPDATE, 0); }
		public UpdateContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_update; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof MessagingGrammarListener ) ((MessagingGrammarListener)listener).enterUpdate(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof MessagingGrammarListener ) ((MessagingGrammarListener)listener).exitUpdate(this);
		}
	}

	public final UpdateContext update() throws RecognitionException {
		UpdateContext _localctx = new UpdateContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_update);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(71);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(70); match(WS);
				}
			}

			setState(73); match(UPDATE);
			setState(74); match(WS);
			setState(89);
			switch (_input.LA(1)) {
			case ROOMS:
				{
				setState(75); match(ROOMS);
				setState(77);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(76); match(WS);
					}
				}

				setState(79); ((UpdateContext)_localctx).rd = json();

						mi = new UpdateRoomsInfo( (((UpdateContext)_localctx).rd!=null?_input.getText(((UpdateContext)_localctx).rd.start,((UpdateContext)_localctx).rd.stop):null) );
					
				}
				break;
			case ITEMS:
				{
				setState(82); match(ITEMS);
				setState(84);
				_la = _input.LA(1);
				if (_la==WS) {
					{
					setState(83); match(WS);
					}
				}

				setState(86); ((UpdateContext)_localctx).id = json();

						mi = new UpdateItemsInfo( (((UpdateContext)_localctx).id!=null?_input.getText(((UpdateContext)_localctx).id.start,((UpdateContext)_localctx).id.stop):null) );	
					
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(92);
			_la = _input.LA(1);
			if (_la==WS) {
				{
				setState(91); match(WS);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class JsonContext extends ParserRuleContext {
		public ObjectContext object() {
			return getRuleContext(ObjectContext.class,0);
		}
		public ArrayContext array() {
			return getRuleContext(ArrayContext.class,0);
		}
		public JsonContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_json; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof MessagingGrammarListener ) ((MessagingGrammarListener)listener).enterJson(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof MessagingGrammarListener ) ((MessagingGrammarListener)listener).exitJson(this);
		}
	}

	public final JsonContext json() throws RecognitionException {
		JsonContext _localctx = new JsonContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_json);
		try {
			setState(96);
			switch (_input.LA(1)) {
			case 2:
				enterOuterAlt(_localctx, 1);
				{
				setState(94); object();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 2);
				{
				setState(95); array();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ObjectContext extends ParserRuleContext {
		public List<PairContext> pair() {
			return getRuleContexts(PairContext.class);
		}
		public PairContext pair(int i) {
			return getRuleContext(PairContext.class,i);
		}
		public ObjectContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_object; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof MessagingGrammarListener ) ((MessagingGrammarListener)listener).enterObject(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof MessagingGrammarListener ) ((MessagingGrammarListener)listener).exitObject(this);
		}
	}

	public final ObjectContext object() throws RecognitionException {
		ObjectContext _localctx = new ObjectContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_object);
		int _la;
		try {
			setState(111);
			switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(98); match(2);
				setState(99); pair();
				setState(104);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==4) {
					{
					{
					setState(100); match(4);
					setState(101); pair();
					}
					}
					setState(106);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(107); match(8);
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(109); match(2);
				setState(110); match(8);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PairContext extends ParserRuleContext {
		public ValueContext value() {
			return getRuleContext(ValueContext.class,0);
		}
		public TerminalNode STRING() { return getToken(MessagingGrammarParser.STRING, 0); }
		public PairContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_pair; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof MessagingGrammarListener ) ((MessagingGrammarListener)listener).enterPair(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof MessagingGrammarListener ) ((MessagingGrammarListener)listener).exitPair(this);
		}
	}

	public final PairContext pair() throws RecognitionException {
		PairContext _localctx = new PairContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_pair);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(113); match(STRING);
			setState(114); match(6);
			setState(115); value();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ArrayContext extends ParserRuleContext {
		public ValueContext value(int i) {
			return getRuleContext(ValueContext.class,i);
		}
		public List<ValueContext> value() {
			return getRuleContexts(ValueContext.class);
		}
		public ArrayContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_array; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof MessagingGrammarListener ) ((MessagingGrammarListener)listener).enterArray(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof MessagingGrammarListener ) ((MessagingGrammarListener)listener).exitArray(this);
		}
	}

	public final ArrayContext array() throws RecognitionException {
		ArrayContext _localctx = new ArrayContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_array);
		int _la;
		try {
			setState(130);
			switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(117); match(5);
				setState(118); value();
				setState(123);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==4) {
					{
					{
					setState(119); match(4);
					setState(120); value();
					}
					}
					setState(125);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(126); match(1);
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(128); match(5);
				setState(129); match(1);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ValueContext extends ParserRuleContext {
		public ObjectContext object() {
			return getRuleContext(ObjectContext.class,0);
		}
		public TerminalNode NUMBER() { return getToken(MessagingGrammarParser.NUMBER, 0); }
		public TerminalNode STRING() { return getToken(MessagingGrammarParser.STRING, 0); }
		public ArrayContext array() {
			return getRuleContext(ArrayContext.class,0);
		}
		public ValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_value; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof MessagingGrammarListener ) ((MessagingGrammarListener)listener).enterValue(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof MessagingGrammarListener ) ((MessagingGrammarListener)listener).exitValue(this);
		}
	}

	public final ValueContext value() throws RecognitionException {
		ValueContext _localctx = new ValueContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_value);
		try {
			setState(139);
			switch (_input.LA(1)) {
			case STRING:
				enterOuterAlt(_localctx, 1);
				{
				setState(132); match(STRING);
				}
				break;
			case NUMBER:
				enterOuterAlt(_localctx, 2);
				{
				setState(133); match(NUMBER);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 3);
				{
				setState(134); object();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 4);
				{
				setState(135); array();
				}
				break;
			case 9:
				enterOuterAlt(_localctx, 5);
				{
				setState(136); match(9);
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 6);
				{
				setState(137); match(7);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 7);
				{
				setState(138); match(3);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static final String _serializedATN =
		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\26\u0090\4\2\t\2"+
		"\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\3\2\3"+
		"\2\3\2\3\2\5\2\31\n\2\3\3\5\3\34\n\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+
		"\3\3\3\3\3\3\3\5\3*\n\3\3\3\5\3-\n\3\3\4\5\4\60\n\4\3\4\3\4\3\4\3\4\3"+
		"\4\3\4\5\48\n\4\3\4\3\4\3\4\3\4\3\4\5\4?\n\4\3\4\3\4\3\4\5\4D\n\4\3\4"+
		"\5\4G\n\4\3\5\5\5J\n\5\3\5\3\5\3\5\3\5\5\5P\n\5\3\5\3\5\3\5\3\5\3\5\5"+
		"\5W\n\5\3\5\3\5\3\5\5\5\\\n\5\3\5\5\5_\n\5\3\6\3\6\5\6c\n\6\3\7\3\7\3"+
		"\7\3\7\7\7i\n\7\f\7\16\7l\13\7\3\7\3\7\3\7\3\7\5\7r\n\7\3\b\3\b\3\b\3"+
		"\b\3\t\3\t\3\t\3\t\7\t|\n\t\f\t\16\t\177\13\t\3\t\3\t\3\t\3\t\5\t\u0085"+
		"\n\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\5\n\u008e\n\n\3\n\2\2\13\2\4\6\b\n\f"+
		"\16\20\22\2\2\u00a4\2\30\3\2\2\2\4\33\3\2\2\2\6/\3\2\2\2\bI\3\2\2\2\n"+
		"b\3\2\2\2\fq\3\2\2\2\16s\3\2\2\2\20\u0084\3\2\2\2\22\u008d\3\2\2\2\24"+
		"\31\3\2\2\2\25\31\5\4\3\2\26\31\5\6\4\2\27\31\5\b\5\2\30\24\3\2\2\2\30"+
		"\25\3\2\2\2\30\26\3\2\2\2\30\27\3\2\2\2\31\3\3\2\2\2\32\34\7\26\2\2\33"+
		"\32\3\2\2\2\33\34\3\2\2\2\34\35\3\2\2\2\35\36\7\16\2\2\36)\7\26\2\2\37"+
		" \7\21\2\2 *\b\3\1\2!\"\7\22\2\2\"*\b\3\1\2#$\7\23\2\2$*\b\3\1\2%&\7\25"+
		"\2\2&\'\7\26\2\2\'(\7\r\2\2(*\b\3\1\2)\37\3\2\2\2)!\3\2\2\2)#\3\2\2\2"+
		")%\3\2\2\2*,\3\2\2\2+-\7\26\2\2,+\3\2\2\2,-\3\2\2\2-\5\3\2\2\2.\60\7\26"+
		"\2\2/.\3\2\2\2/\60\3\2\2\2\60\61\3\2\2\2\61\62\7\17\2\2\62C\7\26\2\2\63"+
		"\64\7\21\2\2\64D\b\4\1\2\65\67\7\22\2\2\668\7\26\2\2\67\66\3\2\2\2\67"+
		"8\3\2\2\289\3\2\2\29:\5\n\6\2:;\b\4\1\2;D\3\2\2\2<>\7\23\2\2=?\7\26\2"+
		"\2>=\3\2\2\2>?\3\2\2\2?@\3\2\2\2@A\5\n\6\2AB\b\4\1\2BD\3\2\2\2C\63\3\2"+
		"\2\2C\65\3\2\2\2C<\3\2\2\2DF\3\2\2\2EG\7\26\2\2FE\3\2\2\2FG\3\2\2\2G\7"+
		"\3\2\2\2HJ\7\26\2\2IH\3\2\2\2IJ\3\2\2\2JK\3\2\2\2KL\7\20\2\2L[\7\26\2"+
		"\2MO\7\21\2\2NP\7\26\2\2ON\3\2\2\2OP\3\2\2\2PQ\3\2\2\2QR\5\n\6\2RS\b\5"+
		"\1\2S\\\3\2\2\2TV\7\24\2\2UW\7\26\2\2VU\3\2\2\2VW\3\2\2\2WX\3\2\2\2XY"+
		"\5\n\6\2YZ\b\5\1\2Z\\\3\2\2\2[M\3\2\2\2[T\3\2\2\2\\^\3\2\2\2]_\7\26\2"+
		"\2^]\3\2\2\2^_\3\2\2\2_\t\3\2\2\2`c\5\f\7\2ac\5\20\t\2b`\3\2\2\2ba\3\2"+
		"\2\2c\13\3\2\2\2de\7\4\2\2ej\5\16\b\2fg\7\6\2\2gi\5\16\b\2hf\3\2\2\2i"+
		"l\3\2\2\2jh\3\2\2\2jk\3\2\2\2km\3\2\2\2lj\3\2\2\2mn\7\n\2\2nr\3\2\2\2"+
		"op\7\4\2\2pr\7\n\2\2qd\3\2\2\2qo\3\2\2\2r\r\3\2\2\2st\7\f\2\2tu\7\b\2"+
		"\2uv\5\22\n\2v\17\3\2\2\2wx\7\7\2\2x}\5\22\n\2yz\7\6\2\2z|\5\22\n\2{y"+
		"\3\2\2\2|\177\3\2\2\2}{\3\2\2\2}~\3\2\2\2~\u0080\3\2\2\2\177}\3\2\2\2"+
		"\u0080\u0081\7\3\2\2\u0081\u0085\3\2\2\2\u0082\u0083\7\7\2\2\u0083\u0085"+
		"\7\3\2\2\u0084w\3\2\2\2\u0084\u0082\3\2\2\2\u0085\21\3\2\2\2\u0086\u008e"+
		"\7\f\2\2\u0087\u008e\7\r\2\2\u0088\u008e\5\f\7\2\u0089\u008e\5\20\t\2"+
		"\u008a\u008e\7\13\2\2\u008b\u008e\7\t\2\2\u008c\u008e\7\5\2\2\u008d\u0086"+
		"\3\2\2\2\u008d\u0087\3\2\2\2\u008d\u0088\3\2\2\2\u008d\u0089\3\2\2\2\u008d"+
		"\u008a\3\2\2\2\u008d\u008b\3\2\2\2\u008d\u008c\3\2\2\2\u008e\23\3\2\2"+
		"\2\26\30\33),/\67>CFIOV[^bjq}\u0084\u008d";
	public static final ATN _ATN =
		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}